﻿#ifndef LECTEUR_H_
#define LECTEUR_H_

#include "Symbole.h"
#include "LecteurSymbole.h"
#include "TableSymboles.h"
#include "Arbre.h"
#include <string>

/**
 * \file Lecteur.h
 * \brief Classe générique de lecture de programmes
 * \author Calabro Anthony / Dominguez José-Paul
 * \date 04 Janvier 2012
 *
 * Classe contenant les fonctions génériques d'interpr&tation d'un programme.
 * Se reporter à la grammaire correspondante.
 */


using namespace std;

class Lecteur
{
    protected:
		LecteurSymbole* ls;
		Noeud* arbre;
		TableSymboles ts;
    public:
	
	/**
 * \fn  Lecteur(string fich)
 * \brief Constructeur de Lecteur.
 *
 * \param fich Chaîne indiquant le chemin du fichier à analyser. ( => LecteurProgramme )
 */
        Lecteur(string fich);
		
		/**
 * \fn  Lecteur(LecteurSymbole* lecs)
 * \brief Constructeur de Lecteur.
 *
 * \param lecs Pointeur sur un Lecteur de Symbole. ( => Lecteur Fonction )
 */
        Lecteur(LecteurSymbole* lecs);
        
			/**
 * \fn  virtual ~Lecteur() {}
 * \brief Destructeur virtuel de Lecteur.
 */
 
		virtual ~Lecteur() {}
/**
 * \fn  virtual Noeud* seqInst()
 * \brief Fonction virtuelle pour créer un noeud contenant une séquence d'instruction.
 * La fonction vérifie que la syntaxe d'une séquence d'instruction est respectée. Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 * \return Pointeur sur noeud contenant une séquence d'instruction.
 */

        virtual Noeud* seqInst();			// <seq_inst> ::=  <inst> ; { <inst> ; }

		/**
 * \fn  virtual virtual Noeud* inst()
 * \brief Fonction virtuelle pour créer un noeud contenant une séquence d'instruction. La syntaxe diffère un peu entre LecteurFonction et LecteurProgramme.
 *     	La fonction vérifie que la syntaxe d'une instruction est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 * 		 <seq_inst> ::=  <inst> ; { <inst> ; }
 * \return Pointeur sur noeud contenant une séquence d'instruction.
 */
		
        virtual Noeud* inst();		// <inst>	::= <affectation> | <instSi> | <instTq> | <instRepeter>
		
		/**
 * \fn  virtual virtual Noeud* affectation()
 * \brief Fonction virtuelle pour créer un noeud contenant une affectation. La syntaxe diffère un peu entre LecteurFonction et LecteurProgramme.
 *	La fonction vérifie que la syntaxe d'une affectation est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<inst>	::= <affectation> | <instSi> | <instTq> | <instRepeter>
 * \return Pointeur sur noeud contenant une affectation.
 */
		
		virtual Noeud* affectation();	// <affectation>::= <variable> = ( <expression> )
		
		/**
 * \fn  Noeud* expression()
 * \brief Fonction pour créer un noeud contenant une expression
 *	La fonction vérifie que la syntaxe d'une expression est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<expression>	::= <terme> { <opAdd> <terme> }
 * \return Pointeur sur noeud contenant une expression.
 */
		
		Noeud* expression();	// <expression>	::= <terme> { <opAdd> <terme> }
		
		/**
 * \fn  Noeud* facteur()
 * \brief Fonction pour créer un noeud contenant un facteur
 *	La fonction vérifie que la syntaxe d'unfacteur est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<facteur>	::= <entier> | <variable> | <opUnaire> <expBool> | ( <expBool> ) | <chaine> | <booleen>
 * \return Pointeur sur noeud contenant un facteur.
 */
		
		Noeud* facteur();		// <facteur>	::= <entier> | <variable> | <opUnaire> <expBool> | ( <expBool> ) | <chaine>
		
				/**
 * \fn  Noeud* terme()
 * \brief Fonction pour créer un noeud contenant un terme.
 *	La fonction vérifie que la syntaxe d'un terme est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<terme>	::= <facteur> { <opMult> <facteur> }
 * \return Pointeur sur noeud contenant un terme.
 */
		
		Noeud* terme();		// <terme>	::= <facteur> { <opMult> <facteur> }
		
/**
* \fn  Symbole opAdd()
 * \brief Fonction pour créer un symbole contenant l'opération lue. opAdd gère les opérations les moins prioritaires.
 *	La fonction vérifie que l'opération lue est bien + ou - .
 *	<opAdd>	::= + | -
 * \return Symbole contenant l'opération du noeud actuellement analysé.
 */
		
		Symbole opAdd();		// <opAdd>	::= + | -
		
		/**
* \fn  Symbole opMult()
 * \brief Fonction pour créer un symbole contenant l'opération lue. opMult gère les opérations les plus prioritaires.
 *	La fonction vérifie que l'opération lue est bien * ou / .
 *	<opAdd>	::= * | /
 * \return Symbole contenant l'opération du noeud actuellement analysé.
 */
		
		Symbole opMult();		// <opMult>	::= * | /

		/**
* \fn  Noeud*  expBool()
 * \brief Fonction pour créer un noeud contenant une expression booléenne.
 *	La fonction vérifie que la syntaxe d'une expression booléenne est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<expBool>	::= <expBoolEt> { <opBoolOu> <expBoolEt> }
 * \return Pointeur sur un Noeud contenant l'expression booléenne complète. (composée d'expBoolEt() et d'expBoolOu()
 */
		
		Noeud* expBool();		// <expBool>	::= <expBoolEt> { <opBoolOu> <expBoolEt> }
		
			/**
* \fn  Noeud*  expBoolEt()()
 * \brief Fonction pour créer un noeud contenant une expression booléenne non prioritaire (opération "et" ).
 *	La fonction vérifie que la syntaxe d'une expression booléenne type "ET" est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<expBoolEt>	::= <relation> {<opBoolEt> <relation> }
 * \return Pointeur sur noeud contenant une expression booléeene type "ET".
 */
		Noeud* expBoolEt();	// <expBoolEt>	::= <relation> {<opBoolEt> <relation> }
		
/**
* \fn  opBoolEt()
 * \brief Fonction pour créer un symbole contenant l'opération lue. opBoolEt() gère l'opération "et".
 *	La fonction vérifie que l'opération lue est bien "et" .
 *	<opAdd>	::= et
 * \return Symbole contenant l'opération du noeud actuellement analysé.
 */
		
		Symbole opBoolEt();	// <opBool>	::= et
		
		/**
* \fn  opBoolOu()
 * \brief Fonction pour créer un symbole contenant l'opération lue. opBoolOu() gère l'opération "ou".
 *	La fonction vérifie que l'opération lue est bien "ou" .
 *	<opAdd>	::= ou
 * \return Symbole contenant l'opération du noeud actuellement analysé.
 */
 
		Symbole opBoolOu();	// <opBool>	::= ou
		
			/**
* \fn  Noeud* relation()
 * \brief Fonction pour créer un noeud contenant une relation.
 *	La fonction vérifie que la syntaxe d'une relation est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	 <relation>	::= <expression> { <opRel> <expression> }
 * \return Pointeur sur noeud contenant une relation.
 */
		
		Noeud* relation();	// <relation>	::= <expression> { <opRel> <expression> }
		
			/**
* \fn  Symbole opRel()
  * \brief Fonction pour créer un symbole contenant l'opération de comparaison lue.
 *	La fonction vérifie que l'opération lue est bien == | != | < | <= | > | >= .
 *	<opRel>	::=  == | != | < | <= | > | >=
 * \return Symbole contenant l'opération de comparaison du noeud actuellement analysé.
 */
		
		Symbole opRel();		// <opRel>	::=  == | != | < | <= | > | >=
		
		/**
* \fn  Symbole opUnaire()
  * \brief Fonction pour créer un symbole contenant l'opération unaire lue. (opération ne s'appliquant qu'à un opérande)
 *	La fonction vérifie que l'opération lue est bien  - | non .
 *	<opUnaire>	::=   - | non
 * \return Symbole contenant l'opération unaire du noeud actuellement analysé.
 */
		
		Symbole opUnaire();	// <opUnaire>	::=   - | non

			/**
* \fn  Noeud* instSi()
 * \brief Fonction pour créer un noeud contenant une instruction si.
 *	La fonction vérifie que la syntaxe d'une instruction si est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	 <instSi>	::= si ( <expBool> ) alors <seqInst> { sinonsi ( <expBool> ) alors <seqInst> } [ sinon <seqInst> ] finsi
 * \return Pointeur sur noeud contenant une instruction si.
 */
		
		Noeud* instSi();		// <instSi>	::= si ( <expBool> ) alors <seqInst> { sinonsi ( <expBool> ) alors <seqInst> } [ sinon <seqInst> ] finsi
		
			/**
* \fn  Noeud* instTq()
 * \brief Fonction pour créer un noeud contenant une instruction Tant Que... Faire.
 *	La fonction vérifie que la syntaxe d'une instruction Tant Que... Faire est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<instTq>	::= tantque ( <expBool> ) faire <seqInst> fintantque
 * \return Pointeur sur noeud contenant une instruction Tant Que... Faire.
 */
		
		Noeud* instTq();		// <instTq>	::= tantque ( <expBool> ) faire <seqInst> fintantque
		
		/**
* \fn  Noeud* instRepeter()
 * \brief Fonction pour créer un noeud contenant une instruction Répéter...Jusqu'à.
 *	La fonction vérifie que la syntaxe d'une instruction Répéter...Jusqu'à est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<instRepeter> ::= repeter <seqInst> jusqua ( <expBool> )
 * \return Pointeur sur noeud contenant une instruction Répéter...Jusqu'à.
 */
		
		Noeud*  instRepeter();	// <instRepeter> ::= repeter <seqInst> jusqua ( <expBool> )
		
			/**
* \fn  Noeud* instPour()
 * \brief Fonction pour créer un noeud contenant une instruction Pour...Faire .
 *	La fonction vérifie que la syntaxe d'une instruction Pour...Faire est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<instPour>	::= pour ( <affectation> ; <expBool> ; <affectation> ) faire <seqInst> finpour
 * \return Pointeur sur noeud contenant une instruction Pour...Faire .
 */
		
		Noeud* instPour();		// <instPour>	::= pour ( <affectation> ; <expBool> ; <affectation> ) faire <seqInst> finpour


		// Entrees - Sorties
		
			/**
* \fn  Noeud* instLire()
 * \brief Fonction pour créer un noeud contenant une instruction Lire . 
 *	La fonction vérifie que la syntaxe d'une instruction Lire est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<instLire>	::= lire ( <variable> )
 * \return Pointeur sur noeud contenant une instruction Lire .
 */
		
		Noeud* instLire();	// <instLire>	::= lire ( <variable> )
		
			/**
* \fn  Noeud* instEcrire()
 * \brief Fonction pour créer un noeud contenant une instruction Ecrire . 
 *	La fonction vérifie que la syntaxe d'une instruction Lire est respectée.  Les nouveaux symboles rencontrés sont ajouté à la table des symboles.
 *	<instEcrire>	::= ecrire ( <expression> | <chaine> )
 * \return Pointeur sur noeud contenant une instruction Ecrire .
 */
		
		Noeud* instEcrire();	// <instEcrire>	::= ecrire ( <expression> | <chaine> )

					/**
* \fn  void testerSymCour (string ch)
 * \brief Fonction qui test le symbole courant en le comparant avec ch.
 *	Si le Symbole courant a la même valeur que ch ou est du type décrit par ch, le programme continue, sinon, une erreur est levée.
 * \param ch Chaine représentant une valeur ou le type du symbole que l'on veut comparer avec le symbole courant.
 */

		void testerSymCour (string ch);  // si symbole courant != ch, erreur : on arrete le programme, sinon rien
/**		
* \fn  void sauterSymCour (string ch)
 * \brief Fonction qui test le symbole courant en le comparant avec ch et passe au mot suivant si aucune erreur est levée.
 *	Si le Symbole courant a la même valeur que ch ou est du type décrit par ch, on passe au symbole suivant, sinon, une erreur est levée.
 * \param ch Chaine représentant une valeur ou le type du symbole que l'on veut comparer avec le symbole courant.
 */
		
    	void sauterSymCour (string ch);  // si symbole courant == ch, on passe au symbole suivant, sinon erreur : on arrete
		
/**		
* \fn  void erreur (string mess)
 * \brief Fonction qui écrit un message d'erreur dans l'invite de commande.
 *	le message d'erreur indique la ligne et le colonne sur laquelle lerreur a été levée. Elle précise quelle type de symbole était attendu et celui trouvé. 
 * \param ch Chaine représentant le Symbole qui était attendu.
 */
		
    	void erreur (string mess);      // affiche les message d'erreur mess et arrete le programme
};

#endif

